home *** CD-ROM | disk | FTP | other *** search
/ Whiteline: Alpha / Whiteline Alpha.iso / progtool / c / tiff_lib / source / tif_fax3.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-22  |  36.6 KB  |  1,025 lines
  1. #pragma warn -use
  2. static char     *sccsid = "@(#)TIFF/tif_fax3.c 1.34, Copyright (c) Sam Leffler, Dieter Linde, "__DATE__;
  3. #pragma warn .use
  4. /*
  5.  * Copyright (c) 1988, 1990 by Sam Leffler, Nov 24 1990
  6.  * All rights reserved.
  7.  *
  8.  * This file is provided for unrestricted use provided that this legend is included on all tape media and as a part of the
  9.  * software program in whole or part.  Users may copy, modify or distribute this file at will.
  10.  *
  11.  * TIFF Library.
  12.  *
  13.  * CCITT Group 3 Facsimile-compatible Compression Scheme Support.
  14.  *
  15.  * This stuff was derived from code by Jef Pozkanzer.
  16.  */
  17. #include <stdlib.h>
  18. #include "tiffio.h"
  19. #include "tif_fax3.h"
  20. #include "t4.h"
  21. #include "g3codes.h"
  22.  
  23. typedef struct {
  24.            Fax3BaseState    b;
  25. } Fax3DecodeState;
  26.  
  27. typedef struct {
  28.         Fax3BaseState    b;
  29.         u_char      *wruns;
  30.         u_char      *bruns;
  31.         short       k;                       /* #rows left that can be 2d encoded */
  32.         short       maxk;            /* max #rows that can be 2d encoded */
  33. } Fax3EncodeState;
  34.  
  35. /****************************************************************************
  36.  *
  37.  */
  38. void
  39. TIFFModeCCITTFax3(
  40.     TIFF     *tif, 
  41.     int      isClassF
  42.     )
  43. {
  44.            if (isClassF)
  45.                    tif->tif_options |= FAX3_CLASSF;
  46.         else
  47.                 tif->tif_options &= ~FAX3_CLASSF;
  48. }
  49.  
  50. #define is2DEncoding(tif)     (tif->tif_dir.td_group3options & GROUP3OPT_2DENCODING)
  51. #define fetchByte(tif, sp)         (sp)->b.bitmap[*(u_char *)(tif)->tif_rawcp++]
  52.  
  53. #define BITCASE(b)              case b: \
  54.                         code <<= 1; \
  55.                         if (data & b) \
  56.                                 code |= 1; \
  57.                         len++; \
  58.                         if (code > 0) { \
  59.                             bit = (b >> 1);    \
  60.                             break; \
  61.                         }
  62.  
  63. /****************************************************************************
  64.  * Skip over input until an EOL code is found.
  65.  */
  66. static void
  67. skiptoeol(
  68.     TIFF     *tif
  69.     )
  70. {
  71.         Fax3DecodeState *sp = (Fax3DecodeState *)tif->tif_data;
  72.         register int    bit = sp->b.bit;
  73.         register int     data = sp->b.data;
  74.         int         code, len;
  75.  
  76.         do {
  77.                 code = len = 0;
  78.                 switch (bit) {
  79.                 again:  
  80.                     BITCASE(0x80);
  81.                         BITCASE(0x40);
  82.                         BITCASE(0x20);
  83.                         BITCASE(0x10);
  84.                         BITCASE(0x08);
  85.                         BITCASE(0x04);
  86.                         BITCASE(0x02);
  87.                         BITCASE(0x01);
  88.                     default:
  89.                             if (tif->tif_rawcc <= 0) {
  90.                                     TIFFError("skiptoeol", "%s: premature EOF at scanline %d", tif->tif_name, tif->tif_row);
  91.                                     return;
  92.                             }
  93.                             data = fetchByte(tif, sp);
  94.                             goto again;
  95.                 }
  96.         } while (len < 12 || code != EOL);
  97.         sp->b.bit = bit;
  98.         sp->b.data = data;
  99. }
  100.  
  101. /****************************************************************************
  102.  * Setup G3-related compression/decompression state before data is processed.  This routine
  103.  * is called once per image -- it sets up different state based on whether or not 2D encoding is used.
  104.  */
  105. static void *
  106. Fax3SetupState(
  107.     TIFF     *tif, 
  108.     int      space
  109.     )
  110. {
  111.         TIFFDirectory     *td = &tif->tif_dir;
  112.         Fax3BaseState     *sp;
  113.         int         cc = space;
  114.  
  115.         if (td->td_bitspersample != 1) {
  116.                 TIFFError(tif->tif_name, "Bits/sample must be 1 for Group 3/4 encoding/decoding");
  117.                 return(0);
  118.         }
  119.         if (is2DEncoding(tif) || td->td_compression == COMPRESSION_CCITTFAX4)
  120.                 cc += tif->tif_scanlinesize;
  121.         tif->tif_data = malloc(cc);
  122.         if (tif->tif_data == NULL) {
  123.                 TIFFError(tif->tif_name, "No space for Fax3 state block");
  124.                 return(0);
  125.         }
  126.         sp = (Fax3BaseState *)tif->tif_data;
  127.         sp->bitmap = (tif->tif_fillorder != td->td_fillorder ? TIFFBitRevTable : TIFFNoBitRevTable);
  128.         sp->white = (td->td_photometric == PHOTOMETRIC_MINISBLACK);
  129.         if (is2DEncoding(tif) || td->td_compression == COMPRESSION_CCITTFAX4) {
  130.  
  131.     /*
  132.          * 2d encoding/decoding requires a scanline buffer for the ``reference line''; the
  133.          * scanline against which delta encoding is referenced.  The referennce line must
  134.          * be initialized to be ``white.''
  135.          */
  136.                 sp->refline = tif->tif_data + space;
  137.                 bzero(sp->refline, tif->tif_scanlinesize);
  138.                 if (sp->white == 1)
  139.                         TIFFReverseBits(sp->refline, tif->tif_scanlinesize);
  140.         } 
  141.         else
  142.                 sp->refline = 0;
  143.         return(sp);
  144. }
  145.  
  146. /****************************************************************************
  147.  * Setup state for decoding a strip.
  148.  */
  149. static int
  150. Fax3PreDecode(
  151.         TIFF     *tif
  152.         )
  153. {
  154.         Fax3DecodeState    *sp = (Fax3DecodeState *)tif->tif_data;
  155.  
  156.         if (sp == NULL) {
  157.                 sp = (Fax3DecodeState *)Fax3SetupState(tif, (int)sizeof(*sp));
  158.                 if (!sp)
  159.                         return(0);
  160.         }
  161.         sp->b.bit = 0;                             /* force initial read */
  162.         sp->b.data = 0;
  163.         sp->b.tag = G3_1D;
  164.  
  165.         /*
  166.          * Non-TIFF/F images have an initial blank line that we need to skip over.  Note that this
  167.          * is only done at the beginning of the image, not at the start of each strip.
  168.          */
  169.         if (tif->tif_curstrip == 0 && (tif->tif_options & FAX3_CLASSF) == 0)
  170.                 skiptoeol(tif);
  171.         return(1);
  172. }
  173.  
  174. /****************************************************************************
  175.  * Fill a span with ones.
  176.  */
  177. static void
  178. fillspan(
  179.            register char    *cp,
  180.         register int     x, 
  181.         register int    count
  182.         )
  183. {
  184.         static u_char    masks[] = { 0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
  185.  
  186.         cp += (x >> 3);
  187.         if (x &= 7) {                      /* align to byte boundary */
  188.                 if (count < 8 - x) {
  189.                         *cp++ |= (masks[count] >> x);
  190.                         return;
  191.                 }
  192.                 *cp++ |= (0xff >> x);
  193.                 count -= 8 - x;
  194.         }
  195.         while (count >= 8) {
  196.                 *cp++ = 0xff;
  197.                 count -= 8;
  198.         }
  199.         *cp |= masks[count];
  200. }
  201.  
  202. /****************************************************************************
  203.  * Process one row of 1d Huffman-encoded data.
  204.  */
  205. static int
  206. Fax3Decode1DRow(
  207.            TIFF     *tif,
  208.         u_char    *buf,
  209.         int     npels
  210.         )
  211. {
  212.         Fax3DecodeState    *sp = (Fax3DecodeState *)tif->tif_data;
  213.         short         bit = sp->b.bit;
  214.         short         data = sp->b.data;
  215.         int         x = 0;
  216.         int         count = 0;
  217.         short         len = 0;
  218.         short         code = 0;
  219.         short         color = sp->b.white;
  220.         tableentry     *te;
  221.         static char     module[] = "Fax3Decode1D";
  222.  
  223.         for (;;) {
  224.                 switch (bit) {
  225.                 again:  
  226.                     BITCASE(0x80);
  227.                         BITCASE(0x40);
  228.                         BITCASE(0x20);
  229.                         BITCASE(0x10);
  230.                         BITCASE(0x08);
  231.                         BITCASE(0x04);
  232.                         BITCASE(0x02);
  233.                         BITCASE(0x01);
  234.                     default:
  235.                             if (tif->tif_rawcc <= 0) {
  236.                             TIFFError(module, "%s: Premature EOF at scanline %d (x %d)", tif->tif_name, tif->tif_row, x);
  237.                                     return(0);
  238.                             }
  239.                             data = fetchByte(tif, sp);
  240.                             goto again;
  241.                 }
  242.                 if (len >= 12) {
  243.                         if (code == EOL) {
  244.                                 if (x == 0) {
  245.                                         TIFFWarning(tif->tif_name, "%s: Ignoring null row at scanline %d", module, tif->tif_row);
  246.                                         code = len = 0;
  247.                                         continue;
  248.                                 }
  249.                                 sp->b.bit = bit;
  250.                                 sp->b.data = data;
  251.                                 TIFFWarning(tif->tif_name, "%s: Premature EOL at scanline %d (x %d)", module, tif->tif_row, x);
  252.                                 return(1);        /* try to resynchronize... */
  253.                         }
  254.                         if (len > 13) {
  255.                                 TIFFError(tif->tif_name, "%s: Bad code word (len %d code 0x%x) at scanline %d (x %d)", module, len, code, tif->tif_row, x);
  256.                                 break;
  257.                         }
  258.                 }
  259.                 if (color == sp->b.white) {
  260.                         u_char     ix = TIFFFax3wtab[code << (13 - len)];
  261.  
  262.                         if (ix == 0xff)
  263.                                 continue;
  264.                         te = &TIFFFax3wcodes[ix];
  265.                 } 
  266.                 else {
  267.                         u_char     ix = TIFFFax3btab[code << (13 - len)];
  268.  
  269.                         if (ix == 0xff)
  270.                                 continue;
  271.                         te = &TIFFFax3bcodes[ix];
  272.                 }
  273.                 if (te->length != len)
  274.                         continue;
  275.                 count += te->count;
  276.                 if (te->tabid < 0) {               /* terminating code */
  277.                         if (x + count > npels)
  278.                                 count = npels - x;
  279.                         if (count > 0) {
  280.                                 if (color)
  281.                                         fillspan((char *)buf, x, count);
  282.                                 x += count;
  283.                                 if (x >= npels)
  284.                                         break;
  285.                         }
  286.                         count = 0;
  287.                         color = !color;
  288.                 }
  289.                 code = len = 0;
  290.         }
  291.         sp->b.data = data;
  292.         sp->b.bit = bit;
  293.  
  294.         /*
  295.          * Cleanup at the end of the row.  This convoluted logic is merely so that we can reuse the code with
  296.          * two other related compression algorithms (2 & 32771).
  297.          *
  298.          * Note also that our handling of word alignment assumes that the buffer is at least word aligned.  This is
  299.          * the case for most all versions of malloc (typically the buffer is returned longword aligned).
  300.          */
  301.         if ((tif->tif_options & FAX3_NOEOL) == 0)
  302.                 skiptoeol(tif);
  303.         if (tif->tif_options & FAX3_BYTEALIGN)
  304.                 sp->b.bit = 0;
  305.         if ((tif->tif_options & FAX3_WORDALIGN) && ((long)tif->tif_rawcp & 1)) {
  306.                 tif->tif_rawcp++;
  307.                 tif->tif_rawcc--;
  308.            }
  309.         return(x == npels);
  310. }
  311.  
  312. /****************************************************************************
  313.  * Decode the requested amount of data.
  314.  */
  315. static int
  316. Fax3Decode(
  317.            TIFF     *tif,
  318.         u_char     *buf,
  319.         int     occ
  320.         )
  321. {
  322.         Fax3DecodeState    *sp = (Fax3DecodeState *)tif->tif_data;
  323.         int         scanline = tif->tif_scanlinesize;
  324.         int         imagewidth = tif->tif_dir.td_imagewidth;
  325.  
  326.         bzero(buf, occ);                   /* decoding only sets non-zero bits */
  327.         while (occ > 0) {
  328.                 if (sp->b.tag == G3_1D) {
  329.                         if (!Fax3Decode1DRow(tif, buf, imagewidth))
  330.                                 return(0);
  331.                 } 
  332.                 else {
  333.                         if (!Fax3Decode2DRow(tif, buf, imagewidth))
  334.                                 return(0);
  335.                 }
  336.                 if (is2DEncoding(tif)) {
  337.  
  338.     /*
  339.          * Fetch the tag bit that indicates whether the next row is 1d or 2d
  340.          * encoded.  If 2d-encoded, then setup the reference line from the decoded
  341.          * scanline just completed.
  342.          */
  343.                         if (sp->b.bit == 0) {
  344.                                 if (tif->tif_rawcc <= 0) {
  345.                                         TIFFError("Fax3Decode", "%s: Premature EOF at scanline %d", tif->tif_name, tif->tif_row);
  346.                                         return(0);
  347.                                 }
  348.                                 sp->b.data = fetchByte(tif, sp);
  349.                                 sp->b.bit = 0x80;
  350.                         }
  351.                         sp->b.tag = (sp->b.data & sp->b.bit) ? G3_1D : G3_2D;
  352.                         sp->b.bit >>= 1;
  353.                         if (sp->b.tag == G3_2D)
  354.                                 bcopy(buf, sp->b.refline, scanline);
  355.                 }
  356.                 buf += scanline;
  357.                 occ -= scanline;
  358.         }
  359.         return(1);
  360. }
  361.  
  362. /*
  363.  * Group 3 2d Decoding support.
  364.  *
  365.  * NB: the order of the decoding modes is used below 
  366.  */
  367. #define MODE_HORIZ         0          /* horizontal mode, handling 1st runlen */
  368. #define MODE_HORIZ1     1       /* horizontal mode, handling 2d runlen */
  369. #define MODE_OTHER      2       /* !horizontal mode */
  370.  
  371. #define PACK(code, len)    (((len) << 2) + (code))
  372.  
  373. /*
  374.  * Group 3 2d decoding modes 
  375.  */
  376. #define PASS               1
  377. #define HORIZONTAL      2
  378. #define VERTICAL        3
  379. #define EXTENSION       4
  380. #define UNCOMPRESSED       1
  381.  
  382. #define PACKINFO(mode, v)    (((v) << 4) + mode)
  383. #define UNPACKMODE(v)           ((v) & 0xf)
  384. #define UNPACKINFO(v)           ((v) >> 4)
  385.  
  386. static short    g32dtab[56] = {
  387.     0,   0,   0,   0,   0,   3,   0,   0,   /* 0x00 - 0x07 */
  388.            0,   0,   0,   0,   0,   2, -13,  19,   /* 0x08 - 0x0f */
  389.            0,   1,   0,   0,   0,   0,   0,   0,   /* 0x10 - 0x17 */
  390.            0,   0, -29,  35,   0,   0, -45,  51,   /* 0x18 - 0x1f */
  391.            0,   0,   0,   0,   0,   0,   0,   0,   /* 0x20 - 0x27 */
  392.            0,   0,   0,   0,   0,   0,   0,   0,   /* 0x28 - 0x2f */
  393.            0,   0,   0,   0,   0,   0,   0,  20,    /* 0x30 - 0x37 */
  394. };
  395.  
  396. #define    NG32D    (sizeof(g32dtab) / sizeof(g32dtab[0]))
  397.  
  398. /*
  399.  * Bit handling utilities.
  400.  */
  401.  
  402. static u_char    zeroruns[256] = {
  403.         8, 7, 6, 6, 5, 5, 5, 5, 4, 4, 4, 4, 4, 4, 4, 4,        /* 0x00 - 0x0f */
  404.         3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,         /* 0x10 - 0x1f */
  405.         2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,         /* 0x20 - 0x2f */
  406.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,         /* 0x30 - 0x3f */
  407.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,         /* 0x40 - 0x4f */
  408.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,         /* 0x50 - 0x5f */
  409.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,         /* 0x60 - 0x6f */
  410.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,         /* 0x70 - 0x7f */
  411.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0x80 - 0x8f */
  412.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0x90 - 0x9f */
  413.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0xa0 - 0xaf */
  414.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0xb0 - 0xbf */
  415.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0xc0 - 0xcf */
  416.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0xd0 - 0xdf */
  417.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0xe0 - 0xef */
  418.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0xf0 - 0xff */
  419. };
  420. static u_char    oneruns[256] = {
  421.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0x00 - 0x0f */
  422.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0x10 - 0x1f */
  423.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0x20 - 0x2f */
  424.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0x30 - 0x3f */
  425.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0x40 - 0x4f */
  426.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0x50 - 0x5f */
  427.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0x60 - 0x6f */
  428.     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,         /* 0x70 - 0x7f */
  429.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,         /* 0x80 - 0x8f */
  430.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,         /* 0x90 - 0x9f */
  431.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,         /* 0xa0 - 0xaf */
  432.     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,         /* 0xb0 - 0xbf */
  433.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,         /* 0xc0 - 0xcf */
  434.     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,         /* 0xd0 - 0xdf */
  435.     3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,         /* 0xe0 - 0xef */
  436.     4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 6, 6, 7, 8,         /* 0xf0 - 0xff */
  437. };
  438.  
  439. /****************************************************************************
  440.  * Find a span of ones or zeros using the supplied table.  The byte-aligned start of the bit string
  441.  * is supplied along with the start+end bit indices.  The table gives the number of consecutive ones or
  442.  * zeros starting from the msb and is indexed by byte value.
  443.  */
  444. static int
  445. findspan(
  446.         u_char         **bpp,
  447.         int         bs, 
  448.         int        be,
  449.         register u_char    *tab
  450.         )
  451. {
  452.         register u_char    *bp = *bpp;
  453.         register int     bits = be - bs;
  454.         register int     n, span;
  455.  
  456.         /*
  457.          * Check partial byte on lhs.
  458.          */
  459.         if (bits > 0 && ((n = (bs & 7)) != 0)) {
  460.                 span = tab[(*bp << n) & 0xff];
  461.                 if (span > 8 - n)         /* table value too generous */
  462.                         span = 8 - n;
  463.                 if (n + span < 8)          /* doesn't extend to edge of byte */
  464.                         goto done;
  465.                 bits -= span;
  466.                 bp++;
  467.         } 
  468.         else
  469.                 span = 0;
  470.  
  471.         /*
  472.          * Scan full bytes for all 1's or all 0's.
  473.          */
  474.         while (bits >= 8) {
  475.                 n = tab[*bp];
  476.                 span += n;
  477.                 bits -= n;
  478.                 if (n < 8)                 /* end of run */
  479.                         goto done;
  480.                 bp++;
  481.         }
  482.  
  483.         /*
  484.          * Check partial byte on rhs.
  485.          */
  486.         if (bits > 0) {
  487.                 n = tab[*bp];
  488.                 span += (n > bits ? bits : n);
  489.         }
  490. done:
  491.         *bpp = bp;
  492.         return(span);
  493. }
  494.  
  495. /****************************************************************************
  496.  * Return the offset of the next bit in the range [bs..be] that is different from bs.  The end,
  497.  * be, is returned if no such bit exists.
  498.  */
  499. static int
  500. finddiff(
  501.         u_char     *cp,
  502.         int     bs, 
  503.         int    be
  504.         )
  505. {
  506.         cp += (bs >> 3);               /* adjust byte offset */
  507.         return(bs + findspan(&cp, bs, be, (*cp & (0x80 >> (bs & 7))) ? oneruns : zeroruns));
  508. }
  509.  
  510. /****************************************************************************
  511.  * Process one row of 2d encoded data.
  512.  */
  513. int
  514. Fax3Decode2DRow(
  515.         TIFF     *tif,
  516.         u_char     *buf,
  517.         int     npels
  518.         )
  519. {
  520. #define    PIXEL(buf, ix)    ((((buf)[(ix) >> 3]) >> (7 - ((ix) & 7))) & 1)
  521.         Fax3DecodeState    *sp = (Fax3DecodeState *)tif->tif_data;
  522.         short         bit = sp->b.bit;
  523.         short         data = sp->b.data;
  524.         short         len = 0;
  525.         short         code = 0;
  526.         int         a0 = 0;
  527.         int         b1 = 0;
  528.         int         b2 = 0;
  529.         int         count = 0;
  530.         short         mode = MODE_OTHER;
  531.         short         color = sp->b.white;
  532.         static char     module[] = "Fax3Decode2D";
  533.  
  534.         do {
  535.                 switch (bit) {
  536.                 again:  
  537.                     BITCASE(0x80);
  538.                         BITCASE(0x40);
  539.                         BITCASE(0x20);
  540.                         BITCASE(0x10);
  541.                         BITCASE(0x08);
  542.                         BITCASE(0x04);
  543.                         BITCASE(0x02);
  544.                         BITCASE(0x01);
  545.                     default:
  546.                             if (tif->tif_rawcc <= 0) {
  547.                                     TIFFError(module, "%s: Premature EOF at scanline %d", tif->tif_name, tif->tif_row);
  548.                                     return(0);
  549.                             }
  550.                             data = fetchByte(tif, sp);
  551.                             goto again;
  552.                 }
  553.                 if (len >= 12) {
  554.                         if (code == EOL) {
  555.                                 if (a0 == 0) {
  556.                                            TIFFWarning(tif->tif_name, "%s: Ignoring null row at scanline %d", module, tif->tif_row);
  557.                                         code = len = 0;
  558.                                         continue;
  559.                                 }
  560.                                 sp->b.bit = bit;
  561.                                 sp->b.data = data;
  562.                                 TIFFWarning(tif->tif_name, "%s: Premature EOL at scanline %d (x %d)", module, tif->tif_row, a0);
  563.                                 return(1);        /* try to resynchronize... */
  564.                         }
  565.                         if (len > 13) {
  566.                                    TIFFError(tif->tif_name, "%s: Bad code word (len %d code 0x%x) at scanline %d", module, len, code, tif->tif_row);
  567.                                 break;
  568.                         }
  569.                 }
  570.                 if (mode != MODE_OTHER) {
  571.                         tableentry    *te;
  572.  
  573.     /*
  574.          * In horizontal mode, collect 1d code words that represent a0.a1 and a1.a2.
  575.          */
  576.                         if (color == sp->b.white) {
  577.                                 u_char ix = TIFFFax3wtab[code << (13 - len)];
  578.                                 if (ix == 0xff)
  579.                                            continue;
  580.                                 te = &TIFFFax3wcodes[ix];
  581.                         } 
  582.                         else {
  583.                                 u_char ix = TIFFFax3btab[code << (13 - len)];
  584.                                 if (ix == 0xff)
  585.                                         continue;
  586.                                 te = &TIFFFax3bcodes[ix];
  587.                         }
  588.                         if (te->length != len)
  589.                                 continue;
  590.                         count += te->count;
  591.                         if (te->tabid < 0) {       /* terminating code */
  592.                                 if (a0 + count > npels)
  593.                                         count = npels - a0;
  594.                                 if (count > 0) {
  595.                                         if (color)
  596.                                                 fillspan((char *)buf, a0, count);
  597.                                         a0 += count;
  598.                                 }
  599.                                 mode++;            /* NB: assumes state ordering */
  600.                                 count = 0;
  601.                                 color = !color;
  602.                         }
  603.                 } 
  604.                 else {
  605.                         int     v = PACK(code, len);
  606.  
  607.                         if (v >= NG32D || ((v = g32dtab[v]) == 0)) {
  608.                                 continue;
  609.                         }
  610.                         switch (UNPACKMODE(v)) {
  611.                             case PASS:
  612.                                     b1 = (a0 || PIXEL(sp->b.refline, 0)) ? finddiff(sp->b.refline, a0, npels) : 0;
  613.                                     if (color == PIXEL(sp->b.refline, b1))
  614.                                         b1 = finddiff(sp->b.refline, b1, npels);
  615.                                     b2 = finddiff(sp->b.refline, b1, npels);
  616.                                     if (color)
  617.                                             fillspan((char *)buf, a0, b2 - a0);
  618.                                     a0 += b2 - a0;
  619.                                     break;
  620.                             case HORIZONTAL:
  621.                                     mode = MODE_HORIZ;
  622.                                     count = 0;
  623.                                     break;
  624.                             case VERTICAL:
  625.                                     b1 = (a0 || PIXEL(sp->b.refline, 0)) ? finddiff(sp->b.refline, a0, npels) : 0;
  626.                                     if (color == PIXEL(sp->b.refline, b1))
  627.                                             b1 = finddiff(sp->b.refline, b1, npels);
  628.                                     b1 += UNPACKINFO(v);
  629.                                     if (color)
  630.                                             fillspan((char *)buf, a0, b1 - a0);
  631.                                     a0 += b1 - a0;
  632.                                     color = !color;
  633.                                     break;
  634.                             case EXTENSION:
  635.                                     /*** XXX fill in... ***/
  636.                                     break;
  637.                         }
  638.                 }
  639.                 code = len = 0;
  640.         } while (a0 < npels);
  641.         sp->b.data = data;
  642.         sp->b.bit = bit;
  643.  
  644.         /*
  645.          * Cleanup at the end of row.  We check for EOL separately so that this code can be
  646.          * reused by the Group 4 decoding routine.
  647.          */
  648.         if ((tif->tif_options & FAX3_NOEOL) == 0)
  649.                 skiptoeol(tif);
  650.         return(a0 >= npels);
  651. #undef     PIXEL
  652. }
  653.  
  654. /*
  655.  * CCITT Group 3 FAX Encoding.
  656.  */
  657.  
  658. /****************************************************************************
  659.  * Write a variable-length bit-value to the output stream.  Values are
  660.  * assumed to be at most 16 bits.
  661.  */
  662. static void
  663. putbits(
  664.          TIFF     *tif,
  665.         u_int     bits, 
  666.         u_int    length
  667.         )
  668. {
  669.         Fax3BaseState    *sp = (Fax3BaseState *)tif->tif_data;
  670.         static int     mask[9] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff };
  671.  
  672.         while (length > sp->bit) {
  673.                 sp->data |= (bits >> (length - sp->bit));
  674.                 if (tif->tif_rawcc >= tif->tif_rawdatasize)
  675.                            TIFFFlushData1(tif);
  676.                 *tif->tif_rawcp++ = sp->bitmap[sp->data];
  677.                 tif->tif_rawcc++;
  678.                 length -= sp->bit;
  679.                 sp->data = 0;
  680.                 sp->bit = 8;
  681.         }
  682.         sp->data |= ((bits & mask[length]) << (sp->bit - length));
  683.         sp->bit -= length;
  684.         if (sp->bit == 0) {
  685.                 if (tif->tif_rawcc >= tif->tif_rawdatasize)
  686.                            TIFFFlushData1(tif);
  687.                 *tif->tif_rawcp++ = sp->bitmap[sp->data];
  688.                 tif->tif_rawcc++;
  689.                 sp->data = 0;
  690.                 sp->bit = 8;
  691.         }
  692. }
  693.  
  694. /****************************************************************************
  695.  * Write a code to the output stream.
  696.  */
  697. static void
  698. putcode(
  699.            TIFF         *tif,
  700.         tableentry     *te
  701.         )
  702. {
  703.         putbits(tif, te->code, te->length);
  704. }
  705.  
  706. /****************************************************************************
  707.  * Write the sequence of codes that describes the specified span of zero's or one's.  The
  708.  * appropriate tables that hold the make-up and terminating codes are supplied.
  709.  */
  710. static void
  711. putspan(
  712.         TIFF         *tif,
  713.         int         span,
  714.         tableentry     *mtab,
  715.         tableentry     *ttab
  716.         )
  717. {
  718.         if (span >= 64) {
  719.                 tableentry    *te = &mtab[(span / 64) - 1];
  720.  
  721.                 putcode(tif, te);
  722.                 span -= te->count;
  723.         }
  724.         putcode(tif, &ttab[span]);
  725. }
  726.  
  727. /****************************************************************************
  728.  * Write an EOL code to the output stream.  The zero-fill logic for byte-aligning encoded scanlines is handled
  729.  * here.  We also handle writing the tag bit for the next scanline when doing 2d encoding.
  730.  *
  731.  * Note that when doing 2d encoding, we byte-align the combination of the EOL + tag bits.  It is unclear
  732.  * (to me) from the documentation whether this is the correct behaviour, or whether the EOL should be
  733.  * aligned and the tag bit should be the first bit in the next byte.  I've implemented what seems to make
  734.  * the most sense.
  735.  */
  736. void
  737. Fax3PutEOL(
  738.            TIFF     *tif
  739.            )
  740. {
  741.         Fax3BaseState    *sp = (Fax3BaseState *)tif->tif_data;
  742.  
  743.         if (tif->tif_dir.td_group3options & GROUP3OPT_FILLBITS) {
  744.  
  745.     /*
  746.          * Force bit alignment so EOL (+tag bit) will terminate on a byte boundary.  That is, force
  747.          * the bit alignment to 16-12 = 4 (or 16-13 = 3 for 2d encoding) before putting out the EOL code.
  748.          */
  749.                 int     align = 8 - (is2DEncoding(tif) ? 3 : 4);
  750.  
  751.                 if (align != sp->bit) {
  752.                         if (align > sp->bit)
  753.                                 align = sp->bit + (8 - align);
  754.                         else
  755.                                 align = sp->bit - align;
  756.                         putbits(tif, 0, align);
  757.                 }
  758.         }
  759.         putbits(tif, EOL, 12);
  760.         if (is2DEncoding(tif))
  761.                 putbits(tif, sp->tag == G3_1D, 1);
  762. }
  763.  
  764. /****************************************************************************
  765.  * Reset encoding state at the start of a strip.
  766.  */
  767. static int
  768. Fax3PreEncode(
  769.         TIFF     *tif
  770.         )
  771. {
  772.         Fax3EncodeState    *sp = (Fax3EncodeState *)tif->tif_data;
  773.  
  774.         if (sp == NULL) {
  775.                 sp = (Fax3EncodeState *)Fax3SetupState(tif, (int)sizeof(*sp));
  776.                 if (!sp)
  777.                         return(0);
  778.                 if (sp->b.white == 0) {
  779.                         sp->wruns = zeroruns;
  780.                         sp->bruns = oneruns;
  781.                 } 
  782.                 else {
  783.                         sp->wruns = oneruns;
  784.                         sp->bruns = zeroruns;
  785.                 }
  786.         }
  787.         sp->b.bit = 8;
  788.         sp->b.data = 0;
  789.         sp->b.tag = G3_1D;
  790.         if (is2DEncoding(tif)) {
  791.                 float res = tif->tif_dir.td_yresolution;
  792.  
  793.     /*
  794.          * The CCITT spec says that when doing 2d encoding, you should only do it on K consecutive scanlines, where K
  795.          * depends on the resolution of the image being encoded (2 for <= 200 lpi, 4 for > 200 lpi).  Since the directory
  796.          * code initializes td_yresolution to 0, this code will select a K of 2 unless the YResolution tag is set
  797.          * appropriately.  (Note also that we fudge a little here and use 150 lpi to avoid problems with units conversion.)
  798.          */
  799.                 if (tif->tif_dir.td_resolutionunit == RESUNIT_CENTIMETER)
  800.                         res = (res * .3937) / 2.54;        /* convert to inches */
  801.                 sp->maxk = (res > 150 ? 4 : 2);
  802.                 sp->k = sp->maxk-1;
  803.         } 
  804.         else
  805.                 sp->k = sp->maxk = 0;
  806.         if ((tif->tif_options & FAX3_CLASSF) == 0 && tif->tif_curstrip == 0)
  807.                 Fax3PutEOL(tif);
  808.         return(1);
  809. }
  810.  
  811. /****************************************************************************
  812.  * 1d-encode a row of pixels.  The encoding is a sequence of all-white or all-black spans
  813.  * of pixels encoded with Huffman codes.
  814.  */
  815. static void
  816. Fax3Encode1DRow(
  817.         TIFF     *tif,
  818.         u_char     *bp,
  819.         int     bits
  820.         )
  821. {
  822.         Fax3EncodeState    *sp = (Fax3EncodeState *)tif->tif_data;
  823.         int         bs = 0;
  824.         int        span;
  825.  
  826.         for (;;) {
  827.                 span = findspan(&bp, bs, bits, sp->wruns);         /* white span */
  828.                 putspan(tif, span, g3mwtab, g3twtab);
  829.                 bs += span;
  830.                 if (bs >= bits)
  831.                         break;
  832.                 span = findspan(&bp, bs, bits, sp->bruns);      /* black span */
  833.                 putspan(tif, span, g3mbtab, g3tbtab);
  834.                 bs += span;
  835.                 if (bs >= bits)
  836.                         break;
  837.         }
  838. }
  839.  
  840. static tableentry    horizcode = { 0x1, 3 };
  841. static tableentry     passcode = { 0x1, 4 };
  842.  
  843. static tableentry     vcodes[7] = {
  844.                 { 0x3, 7 }, 
  845.                 { 0x3, 6 }, 
  846.                 { 0x3, 3 },
  847.                     { 0x1, 1 },
  848.                     { 0x2, 3 }, 
  849.                     { 0x2, 6 }, 
  850.                     { 0x2, 7 },
  851. };
  852.  
  853. /****************************************************************************
  854.  * 2d-encode a row of pixels.  Consult the CCITT documentation for the algorithm.
  855.  */
  856. int
  857. Fax3Encode2DRow(
  858.         TIFF     *tif,
  859.         u_char     *bp, 
  860.         u_char    *rp,
  861.         int     bits
  862.         )
  863. {
  864. #define PIXEL(buf, ix)    ((((buf)[(ix) >> 3]) >> (7 - ((ix) & 7))) & 1)
  865.         short    white = ((Fax3BaseState *)tif->tif_data)->white;
  866.         int     a0 = 0;
  867.         int     a1 = (PIXEL(bp, 0) != white ? 0 : finddiff(bp, 0, bits));
  868.         int     a2 = 0;
  869.         int     b1 = (PIXEL(rp, 0) != white ? 0 : finddiff(rp, 0, bits));
  870.         int     b2 = 0;
  871.  
  872.         for (;;) {
  873.                 b2 = finddiff(rp, b1, bits);
  874.                 if (b2 >= a1) {
  875.                         int    d = b1 - a1;
  876.  
  877.                         if (!(-3 <= d && d <= 3)) {        /* horizontal mode */
  878.                                 a2 = finddiff(bp, a1, bits);
  879.                                 putcode(tif, &horizcode);
  880.                                 if (a0 + a1 == 0 || PIXEL(bp, a0) == white) {
  881.                                         putspan(tif, a1 - a0, g3mwtab, g3twtab);
  882.                                         putspan(tif, a2 - a1, g3mbtab, g3tbtab);
  883.                                 } 
  884.                                 else {
  885.                                         putspan(tif, a1 - a0, g3mbtab, g3tbtab);
  886.                                         putspan(tif, a2 - a1, g3mwtab, g3twtab);
  887.                                 }
  888.                                 a0 = a2;
  889.                         } 
  890.                         else {                           /* vertical mode */
  891.                                 putcode(tif, &vcodes[d + 3]);
  892.                                 a0 = a1;
  893.                         }
  894.                 } 
  895.                 else {                                    /* pass mode */
  896.                         putcode(tif, &passcode);
  897.                         a0 = b2;
  898.                 }
  899.                 if (a0 >= bits)
  900.                         break;
  901.                 a1 = finddiff(bp, a0, bits);
  902.                 b1 = finddiff(rp, a0, bits);
  903.                 if (PIXEL(rp, b1) == PIXEL(bp, a0))
  904.                         b1 = finddiff(rp, b1, bits);
  905.         }
  906.         return(1);
  907. #undef     PIXEL
  908. }
  909.  
  910. /****************************************************************************
  911.  * Encode a buffer of pixels.
  912.  */
  913. static int
  914. Fax3Encode(
  915.         TIFF     *tif,
  916.         u_char     *bp,
  917.         int     cc
  918.         )
  919. {
  920.         Fax3EncodeState    *sp = (Fax3EncodeState *)tif->tif_data;
  921.         int         scanline = tif->tif_scanlinesize;
  922.         int         imagewidth = tif->tif_dir.td_imagewidth;
  923.  
  924.         while (cc > 0) {
  925.                 if (is2DEncoding(tif)) {
  926.                         if (sp->b.tag == G3_1D) {
  927.                                    Fax3Encode1DRow(tif, bp, imagewidth);
  928. /*                                 if (!Fax3Encode1DRow(tif, bp, imagewidth))
  929.                                         return(0);*/
  930.                                 sp->b.tag = G3_2D;
  931.                         } 
  932.                         else {
  933.                                    if (!Fax3Encode2DRow(tif, bp, sp->b.refline, imagewidth))
  934.                                         return(0);
  935.                                 sp->k--;
  936.                         }
  937.                         if (sp->k == 0) {
  938.                                 sp->b.tag = G3_1D;
  939.                                 sp->k = sp->maxk - 1;
  940.                         } 
  941.                         else
  942.                                 bcopy(bp, sp->b.refline, scanline);
  943.                 } 
  944.                 else {
  945.                         Fax3Encode1DRow(tif, bp, imagewidth);
  946. /*                      if (!Fax3Encode1DRow(tif, bp, imagewidth))
  947.                                 return(0);*/
  948.                 }
  949.                 Fax3PutEOL(tif);
  950.                 bp += scanline;
  951.                 cc -= scanline;
  952.         }
  953.         return(1);
  954. }
  955.  
  956. /****************************************************************************
  957.  *
  958.  */
  959. static int
  960. Fax3PostEncode(
  961.         TIFF     *tif
  962.         )
  963. {
  964.         Fax3EncodeState    *sp = (Fax3EncodeState *)tif->tif_data;
  965.  
  966.         if (sp->b.bit != 8) {
  967.                 if (tif->tif_rawcc >= tif->tif_rawdatasize && !TIFFFlushData1(tif))
  968.                         return(0);
  969.                 *tif->tif_rawcp++ = sp->b.bitmap[sp->b.data];
  970.                 tif->tif_rawcc++;
  971.         }
  972.         return(1);
  973. }
  974.  
  975. /****************************************************************************
  976.  *
  977.  */
  978. static void
  979. Fax3Close(
  980.         TIFF     *tif
  981.         )
  982. {
  983.         if ((tif->tif_options & FAX3_CLASSF) == 0) {       /* append RTC */
  984.                 int     i;
  985.  
  986.                 for (i = 0; i < 6; i++)
  987.                         Fax3PutEOL(tif);
  988.                    Fax3PostEncode(tif);
  989.         }
  990. }
  991.  
  992. /****************************************************************************
  993.  *
  994.  */
  995. static void
  996. Fax3Cleanup(
  997.         TIFF     *tif
  998.         )
  999. {
  1000.         if (tif->tif_data) {
  1001.                 free(tif->tif_data);
  1002.                 tif->tif_data = NULL;
  1003.         }
  1004. }
  1005.  
  1006. /****************************************************************************
  1007.  *
  1008.  */
  1009. int
  1010. TIFFInitCCITTFax3(
  1011.     TIFF     *tif
  1012.     )
  1013. {
  1014.         tif->tif_stripdecode = Fax3PreDecode;
  1015.         tif->tif_decoderow = Fax3Decode;
  1016.         tif->tif_stripencode = Fax3PreEncode;
  1017.         tif->tif_encoderow = Fax3Encode;
  1018.         tif->tif_encodestrip = Fax3PostEncode;
  1019.         tif->tif_close = Fax3Close;
  1020.         tif->tif_cleanup = Fax3Cleanup;
  1021.         tif->tif_options |= FAX3_CLASSF;        /* default */
  1022.         tif->tif_flags |= TIFF_NOBITREV;        /* we handle bit reversal */
  1023.         return(1);
  1024. }
  1025.